package com.atguigu.tingshu.album.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.album.service.VodService;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

    @Autowired
    private AlbumInfoMapper albumInfoMapper;
    @Autowired
    private AlbumAttributeValueMapper albumAttributeValueMapper;
    @Autowired
    private AlbumStatMapper albumStatMapper;
    @Autowired
    private TrackInfoMapper trackInfoMapper;
    @Autowired
    private VodService vodService;
    @Autowired
    private RabbitService rabbitService;

    /**
     * 保存专辑信息
     * @param albumInfoVo
     * @param userId
     */
    @Override
    @Transactional(rollbackFor = Exception.class) //默认RuntimeException跟Error回滚事务
    public void saveAlbumInfo(AlbumInfoVo albumInfoVo, Long userId) {
        //1 创建专辑对象
        /*AlbumInfo albumInfo = new AlbumInfo();*/
        //1 给专辑对象赋值
        AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
        albumInfo.setUserId(userId);
        //1.2 设置免费试听集数
        albumInfo.setTracksForFree(5);
        //1.3 设置专辑内容审核状态
        if (vodService.scanText(albumInfo.getAlbumTitle())&&vodService.scanText(albumInfo.getAlbumIntro())){
            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
            //使用消息队列进行上传到索引库
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER,albumInfo.getId());
        }else{
            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_NO_PASS);
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,albumInfo.getId());
            throw new RuntimeException("专辑内容审核失败");
        }
        //1.5 保存专辑对象
        albumInfoMapper.insert(albumInfo);
        //1.4 获取专辑id
        Long albumInfoId = albumInfo.getId();

        //2 遍历队列,保存关系表
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
        if (CollectionUtil.isNotEmpty(albumAttributeValueVoList)) {
            for (AlbumAttributeValueVo albumAttributeValueVo : albumAttributeValueVoList) {
                AlbumAttributeValue albumAttributeValue = BeanUtil.copyProperties(albumAttributeValueVo, AlbumAttributeValue.class);
                albumAttributeValue.setAlbumId(albumInfoId);
                //2.1 保存关系表
                albumAttributeValueMapper.insert(albumAttributeValue);
            }
        }

        //3 记录其他的数量，保存专辑统计表
        this.saveAlbumInfoStat(albumInfoId, SystemConstant.ALBUM_STAT_PLAY, 0);
        this.saveAlbumInfoStat(albumInfoId, SystemConstant.ALBUM_STAT_SUBSCRIBE, 0);
        this.saveAlbumInfoStat(albumInfoId, SystemConstant.ALBUM_STAT_BUY, 0);
        this.saveAlbumInfoStat(albumInfoId, SystemConstant.ALBUM_STAT_COMMENT, 0);

    }

    @Override
    public void saveAlbumInfoStat(Long albumId, String statType, int statNum) {
        AlbumStat albumStat = new AlbumStat();
        albumStat.setAlbumId(albumId);
        albumStat.setStatType(statType);
        albumStat.setStatNum(statNum);
        albumStatMapper.insert(albumStat);
    }

    /**
     * 分页查询用户专辑信息
     * @param page
     * @param limit
     * @param albumInfo
     * @return
     */
    @Override
    public Page<AlbumListVo> findUserAlbumPage(Page<AlbumListVo> pageInfo, AlbumInfoQuery albumInfoQuery) {
        return albumInfoMapper.findUserAlbumPage(pageInfo, albumInfoQuery);
    }

    /**
     * 删除专辑信息
     * @param id
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void removeAlbumInfoById(Long id) {

        //1.根据专辑ID查询关联声音数量
        LambdaQueryWrapper<TrackInfo> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TrackInfo::getAlbumId, id);
        Long count = trackInfoMapper.selectCount(queryWrapper);
        //Long count = trackInfoMapper.selectCount(new LambdaQueryWrapper<TrackInfo>().eq(TrackInfo::getAlbumId, id));
        if (count > 0) {
            throw new RuntimeException("专辑下有声音，不能删除");
        }
        //删除专辑信息
        albumInfoMapper.deleteById(id);
        //删除专辑属性关联表
        albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));
        //删除专辑统计表
        albumStatMapper.delete(new LambdaQueryWrapper<AlbumStat>().eq(AlbumStat::getAlbumId, id));

        rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);
    }

    /**
     * 回显
     * @param id
     * @return
     */
    @Override
    public AlbumInfo getAlbumInfoById(Long id) {
        //1 查询专辑信息
        AlbumInfo albumInfo = albumInfoMapper.selectById(id);
        Assert.notNull(albumInfo, "专辑{}不存在", id);

        LambdaQueryWrapper<AlbumAttributeValue> albumAttributeValueLambdaQueryWrapper = new LambdaQueryWrapper<>();
        albumAttributeValueLambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId, id);
        List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(albumAttributeValueLambdaQueryWrapper);
        if (CollectionUtil.isNotEmpty(albumAttributeValueList)) {
            albumInfo.setAlbumAttributeValueVoList(albumAttributeValueList);
        }
        return albumInfo;
    }

    /**
     * 更新专辑信息
     * @param id
     * @param albumInfoVo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
        //1修改专辑信息
        AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
        albumInfo.setId(id);
        if (vodService.scanText(albumInfo.getAlbumTitle())&&vodService.scanText(albumInfo.getAlbumIntro())){
            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
            //使用消息队列进行上传到索引库
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER,albumInfo.getId());
        }else{
            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_NO_PASS);
            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,albumInfo.getId());
            throw new RuntimeException("专辑内容审核失败");
        }
        albumInfo.setUpdateTime(new Date());
        albumInfoMapper.updateById(albumInfo);

        //2删除专辑属性关联表
        albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
        //2遍历队列,保存关系表
        if (CollectionUtil.isNotEmpty(albumAttributeValueVoList)) {
            for (AlbumAttributeValueVo albumAttributeValueVo : albumAttributeValueVoList) {
                AlbumAttributeValue albumAttributeValue = BeanUtil.copyProperties(albumAttributeValueVo, AlbumAttributeValue.class);
                albumAttributeValue.setAlbumId(id);
                albumAttributeValueMapper.insert(albumAttributeValue);
            }
        }

    }

    /**
     * 获取用户专辑列表
     * @param userId
     * @return
     */
    @Override
    public List<AlbumInfo> findUserAllAlbumList(Long userId) {
        //1 写入查询条件
        LambdaQueryWrapper<AlbumInfo> albumInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        albumInfoLambdaQueryWrapper.eq(AlbumInfo::getUserId, userId);
        //2 限制查询结果字段
        albumInfoLambdaQueryWrapper.select(AlbumInfo::getId,AlbumInfo::getAlbumTitle);
        //3 排序
        albumInfoLambdaQueryWrapper.orderByDesc(AlbumInfo::getCreateTime);
        //4 限制查询条数
        albumInfoLambdaQueryWrapper.last("limit 100");
        //5 查询出列表
        List<AlbumInfo> albumInfos = albumInfoMapper.selectList(albumInfoLambdaQueryWrapper);
        return albumInfos;
    }

    /**
     * 根据专辑id查询统计信息
     *
     * @param albumId
     * @return
     */
    @Override
    public AlbumStatVo getAlbumStatVobyId(Long albumId) {
        return albumInfoMapper.getAlbumStatVobyId(albumId);
    }


    /**
     * 查询专辑声音分页列表
     *
     * @param pageInfo
     * @param albumId
     * @return
     */

}
